﻿#pragma once
#include <iostream>
#include <vector>
#include <time.h>
using std::cout;
using std::endl;

#ifdef _WIN32
#include<windows.h>
#else
// 
#endif

inline static void* SystemAlloc(size_t kpage)
{
#ifdef _WIN32
	void* ptr = VirtualAlloc(0, kpage << 13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#else
	
#endif

	if (ptr == nullptr)
		throw std::bad_alloc();

	return ptr;
}

template<class T>
class ObjectPool
{
	// 我们不知道用户使用这个定长内存池存什么类型的数据
	using ObjectPoolPointType = char*;
public:
	T* New() // 用户使用定长内存池new对象
	{
		T* obj = nullptr;
		// 优先将还回来了内存重复利用
		if (_freeList)
		{
			void* next = *(void**)_freeList;
			obj = (T*)_freeList;
			_freeList = next;
			return obj;
		}
		else
		{
			// 当对象内存池的剩余大小不够一个对象大小时, 则重新开一大块空间
			if (_remainBytes < sizeof(T))
			{
				_remainBytes = 128 * 1024;
				// _memory = (ObjectPoolPointType)malloc(128 * 1024); // 128KB
				_memory = (ObjectPoolPointType)SystemAlloc(_remainBytes >> 13);
				if (nullptr == _memory)
				{
					throw std::bad_alloc();
				}
			}

			// 为这个对象获取空间
			obj = (T*)_memory;
			// 如果这个对象小于8个字节, 就给他8个字节, 大于8个字节, 就给他对应的大小
			size_t objSize = sizeof(obj) > sizeof(void*) ? sizeof(obj) : sizeof(void*);
			_memory += objSize;
			_remainBytes -= objSize;
			// 在这块空间上初始化这个对象
			new(obj)T;
			// 返回对象
			return obj; 
		}
	}
	void Delete(T* obj)
	{
		// 析构对象
		obj->~T();
		// 归还空间
		*(void**)obj = _freeList;
		_freeList = obj;
	}
private:
	ObjectPoolPointType _memory = nullptr; // 指向对象内存池的指针
	size_t _remainBytes = 0; // 大块内存池所剩空间
	void* _freeList = nullptr; // 使用完对象内存池的空间返回用的链表
};


// struct TreeNode
// {
// 	int _val;
// 	TreeNode* _left;
// 	TreeNode* _right;

// 	TreeNode()
// 		:_val(0)
// 		, _left(nullptr)
// 		, _right(nullptr)
// 	{
// 	}
// };

// void TestObjectPool()
// {
// 	// 申请释放的轮次
// 	const size_t Rounds = 5;

// 	// 每轮申请释放多少次
// 	const size_t N = 100000;

// 	std::vector<TreeNode*> v1;
// 	v1.reserve(N);

// 	size_t begin1 = clock();
// 	for (size_t j = 0; j < Rounds; ++j)
// 	{
// 		for (int i = 0; i < N; ++i)
// 		{
// 			v1.push_back(new TreeNode);
// 		}
// 		for (int i = 0; i < N; ++i)
// 		{
// 			delete v1[i];
// 		}
// 		v1.clear();
// 	}

// 	size_t end1 = clock();

// 	std::vector<TreeNode*> v2;
// 	v2.reserve(N);

// 	ObjectPool<TreeNode> TNPool;
// 	size_t begin2 = clock();
// 	for (size_t j = 0; j < Rounds; ++j)
// 	{
// 		for (int i = 0; i < N; ++i)
// 		{
// 			v2.push_back(TNPool.New());
// 		}
// 		for (int i = 0; i < N; ++i)
// 		{
// 			TNPool.Delete(v2[i]);
// 		}
// 		v2.clear();
// 	}
// 	size_t end2 = clock();

// 	cout << "new cost time:" << end1 - begin1 << endl;
// 	cout << "object pool cost time:" << end2 - begin2 << endl;
// }